%% debut du chapitre sur le pretraitement
\chapter{ OCRed }
%%mettre ca en jolie pour TESTU
par guilbep et dimok
%%mettre ca en jolie pour TESTU

%%debut chapitre sur le programme ocred
\chapter{ OCRed qu'est-ce que c'est ? }
 OCRed est n\'e des mots Ocre et digital, qui rappellons le encore une fois
 signifient ``Optical Character Recognition enhanced'' pour l'un et
 num\'erique pour l'autre. La partie du projet portant sur le
 pr\'etraitement de l'image devant \^etre faite en ocaml, OCRed est
 totalement r\'ealis\'e dans ce langage.

\section{ Visualisation de l'image grace a l'executable }
 La cr\'eation du logiciel de traitement de l'image nous a men\'e, au
 d\'ebut du projet \'a vouloir visualiser directement, c'est \'a dire
 sans logiciel tiers, l'action de notre travail.
 La visualisation des images trait\'ees permet notre ind\'ependance
 au niveau de l'utilisation du logiciel, ce qui est un confort certain.
 La fen\^etre est r\'ealis\'ee avec OcamlSDL, tout comme le pr\'etraitement
 de l'image.
%% mettre image de la fenetre sdl
%% visualisation.jpg

v\section{ Utilisation de l'\'executable }
 L'ex\'ecutable en ligne de commande admet un certain nombre d'arguments,
 certains ne pouvant \'evidemment donner lieu \`a un quelconque r\'esultat
 sans la sp\'ecification d'une image d'entr\'ee.
\subsection{ Sp\'ecifier une image d'entr\'ee }
 Il est plus logique, pour un logiciel de traitement d'image, d'avoir
 une image \`a traiter. Vous devez pour cela utiliser l'argument ``-i''
 suivi du chemin d'une image de type jpeg,bmp,png au moins.
\subsection{ Sp\'ecifier une image de sortie }
 Vous n'\^etes pas oblig\'e de pr\'eciser le chemin de l'image de sortie
 mais cela permet une certaine flexibilit\'e. Dans le cas o\`u vous
 n'indiquez pas la sortie, OCRed se debrouille pour sortir une image
 avec un nom assez \'evident, d\'ependant du traitement. Par exemple
 rotatation.bmp ou encore tresholded.bmp, les images se trouveront l\`a
 o\`u vous avez ex\'ecut\'e votre programme. Pour sp\'ecifier un chemin de
 sortie, veuillez utiliser l'argument ``-o'' suivi du chemin d'une image
de type jpeg,bmp,png au moins.
\subsection{ La visualisation de l'image }
 Gr\^ace \`a OcamlSDL, nous pouvons visualiser notre image, il faut pour
 cela sp\'ecifier une image d'entr\'ee, et passer l'argument ``-d'' en
 param\`etre. Les d\'esavantages de l'utilisation de cette interface sont
 assez subtils, par exemple vous ne pouvez ni zoomer ni d\'ezoomer, ni
 vous d\'eplacer sur l'image. Toutefois il y'a (aussi) des avantages, vous pouvez
 visualiser directement les modifications appliqu\'ees \`a votre
 image. En appuyant sur F2 vous faites tourner l'image de l'angle que
 vous avez pass\'e en param\`etre --voir plus loin--. En appuyant sur F3
 vous appliquez le seuil, que vous pouvez sp\'ecifier en ligne de
 commande. En appuyant sur F4, vous appliquez le filtre m\'edian. Nous
 tenons \`a vous rappeler que le seuil ne marche que sur les couleurs.
 Pour quitter il suffit d'appuyer sur F1, la petite croix en haut \`a
 droite ne marche pas.
\subsection{ Le seuil }
 Permet le passage d'une image en noir et blanc, pour avoir un minimum
 de pertes d'informations vous devez sp\'ecifier un seuil viable. Par
 d\'efaut le seuil est \`a 200, ce qui est suffisant pour un contraste
 normal de l'image. Vous devrez l'augmenter si il est trop faible et le
 baisser dans le cas contraire. Passer l'argument ``-s'' en
 param\`etre si vous voulez changer la valeur par d\'efaut. Pour
 l'anecdote ``-s'' viendrait de seuil, mais nous n'en sommes pas vraiment
 s\^urs.
\subsection{ Rotation }
 Vous pouvez passer un angle en pr\'ecision r\'eelle, ou enti\`ere. Pour
 cela passez respectivement l'angle avec l'argument ``-af'' et ``-a''.
 Rappelons que l'angle pass\'e en param\`etre est en degr\'es et non en
 radian. Vous pouvez aussi tourner l'image de 90 degr\'es dans le sens
 direct ou indirect, gr\^ace aux options ``-right'' et ``-left''.
\subsection{ Redimensionnement }
 Le redimensionnement peut s'effectuer en pourcentage de l'image avec
 l'option ``--resizepercent'' qui prend en param\`etre un pourcentage
 entier. L'on peut aussi redimensionner l'image en valeur absolue
 --c'est \`a dire en sp\'ecifiant des valeurs de hauteur et de largeur
 arbitraires--. Alexandre Testu avait besoin d'un petit redimensionnement
 rien que pour lui, c'est pour cela que l'option ``--resize-auto''
 existe.
\subsection{ D\'etection d'angle}
 Il existe un argument magique ``-dev'' qui a juste besoin d'avoir une
 image qui n'est pas bien droite en param\`etre. Il retourne directement
 l'image dans le bon sens, et en noir et blanc, a vos risques et perils.
\subsection{ Help me if you can! }
 L'option ``-help'' est aussi pr\'esente afin d'accompagner
 l'utilisateur dans sa d\'ecouverte du programme. Pour tout autre
 interrogation, il se peut que vous puissiez trouver des informations
 plus ou moins utiles dans les sources du projet, au niveau du fichier
 README.
%%fin chapitre sur le programme ocred


%%debut chapitre detection de l'angle
\chapter{ La d\'etection de l'angle }
 La d\'etection de l'angle \'etait \`a faire pour la premi\`ere
 soutenance, malheureusement par un manque de temps certain elle ne f\^ut
 pas pr\^ete \`a temps. Nous arrivons \`a la troisi\'eme soutenance avec
 deux types de d\'etection de l'angle de rotation du texte d'une image,
 ce qui a pour but de redresser l'image, afin d'avoir une segmentation
 \`a peu pr\`es correcte.

\section{ Des principes assez diff\'erents}
 La d\'etection de l'angle de rotation d'un texte dans une image est un
 probl\`eme assez complexe. En effet une image contenant du texte n'est
 pas compos\'ee de composantes continues, il est donc plus difficile d'isoler
 les caract\'eristiques des \'el\'ements. Deux principes majeurs nous
 sont apparus. Tout d'abord l'on \'etudie les caract\'eristiques d'une
 image pour chaque angle, on isole ensuite le bon angle ; ce
 processus est long et d'autre part encore assez impr\'ecis.
 L'autre principe \'etait de d\'etecter la pente d'une ligne de caract\`eres.
\subsection{ La multiple rotation }
 Dans cet algorithme, l'on reduit la taille de l'image pour gagner en
 temps d'ex\'ecution, le redimensionnement est calcul\'e en fonction de la
 taille d'origine de l'image, on suppose avoir du format A4 \`a chaque
 fois. On proc\`ede comme suit: On tourne de fa\c con dichotomique
 l'image, c'est \`a dire en prenant des angles plus ou moins
 grand. Jusqu'a trouv\'e un histogramme convenable. L'histogramme est
 produit \`a partir de la projection de tout les pixels de l'image sur
 l'axe des horizontales.

Preuve exp\'erimentale produite \`a partir d' une image multifontes,
multicouleurs, mulicolonnes:

 Comme vous pouvez le voir sur ces images, il est \'evident qu'il y'a une
 nette diff\'erence entre des images avec un texte mal orient\'e et un
 texte orthonormal. (mais o\`u est l'orthonormalit\'e dans ce monde ?)

%% histogramme5degree.jpg
%% commentaire de l'image

Sur cette image on peut voir un histogramme d'une image avec un
texte ayant subi une rotation de 5 degr\'es. Il est clair que le nombre
de zone ou l'histogramme atteint 0 en ordonn\'ee est beaucoup plus faible
que les autres images ; environ 8.


%% rotation1deghisto.jpg
%% commentaire de l'image

Sur cette image on peut voir un histogramme d'une image avec un texte
ayant subi une rotation de 1 degr\'e. Par rapport \`a l'image
pr\'ec\'edente, on voit de fa\c con \'evidente que le nombre d'ordonn\'ees
\`a z\'ero est bien plus grand avec un angle de un degr\'e ; ici environ 18.

%% histogramme_bon.jpg
%% commentaire de l'image

Sur cette image on peut voir un histogramme d'une image avec un texte
n'ayant pas subi de rotation. Il est tr\'es net que le nombre
d'ordonn\'ees \`a z\'ero est le plus \'elev\'e.

Il est facile d'implementer un algo qui compte le nombre de bandes
proche de z\'ero ; il s'av\`ere que nous avons voulu compter le nombre de
sommets, ce qui est beaucoup moins pr\'ecis. La m\'ethode expos\'ee
ci-dessus semble bien marcher en th\'eorie.

\subsection{ Detection de la pente }
On d\'etecte la pente d'une ligne de texte ; pour cela on parcourt
l'image pour chaque ligne de pixels jusqu'\`a ce que l'on tombe sur un
pixel noir. Ceci permet d'avoir une certaine id\'ee de la pente d'une ligne
de texte. La tangente de cette pente nous donne l'angle par rapport \`a
la verticale. On la soustrait \`a 90 degr\'es si elle est positive, on
l'ajoute sinon. On se retrouve avec un angle qui correspond, avec un
taux d'erreur proche du dixi\'eme de degr\'e d'angle.

% mettre l'image histo_pente.jpg
% commentaire image histo_pente

Les extrema locaux de la courbe sont beaucoup moins \'elev\'es en
terme de valeurs. Ce qui a pour cons\'equence, une pente peu \'elev\'ee et donc un angle tr\`es \'elev\'e.

% mettre l'image histo_pent_noangle.jpg
% commentaire image histo_pent_noangle

Les extrema locaux de la courbe sont beaucoup plus \'elev\'es en
terme de valeurs que ceux de la courbe pr\'ec\'edente. Ce qui a pour
cons\'equence, une pente tres \'elev\'ee et donc un angle tr\'es faible.

Le probl\`eme avec cette technique, et le manque de pr\'ecision autour
de l'angle nul, et des bruits trop importants produits par des lignes,
tableaux, ou images impromptus.

Nous avons pourtant retenu cette technique pour cette soutenance, car
donnant lieu \`a des r\'esultats plus probants que la m\'ethode expos\'ee
plus haut.

\section{ Optimisations des algorithmes }
 L'optimisation est un crit\`ere de confort pour l'utilisateur, mais
 surtout un gage de qualit\'e.
\subsection{ R\'eduction de l'image }
 Afin de pouvoir augmenter la rapidit\'e des algorithmes de d\'etection
 d'angle, nous r\'eduisons l'image de sorte qu'il y ait le moins de
 pertes d'informations n\'ecessaires \`a cette derni\`ere. A titre
 d'exemple une image au format A4 en 75 dpi, a une taille approximative
 de 900 par 700. Les caract\`eres pr\'esents dans cette image ont une
 taille en pixels d'\`a peu pr\`es 8 pixels. Il ne faut donc pas trop
 r\'eduire l'image, environ 40 pourcents de la taille originale. Au
 contraire pour une image de plus haute d\'efinition, par exemple 600
 dpi, il est n\'ecessaire de r\'eduire l'image \`a au moins 5 pourcents
 de la taille originale. Et comme dirait Junior, ``l'id\'ee c'est
 que'' la rotation d'une image r\'eduite \`a 5 pourcents prend environ
 0,05 secondes sur les machines du PIE, alors qu'elle prend plus de 30
 secondes pour une image en 600 dpi.

%% reduceimage20percent75dpit.jpg
Une image r\'eduite.

Remarque, il est int\'eressant de voir qu'une image r\'eduite comporte
moins de bruit, qui fausserait l'avanc\'ee de l'algo de reconnaissance
des plages nulles.

\subsection{ Ce qu'il nous reste \`a faire}
\subsubsection{ D\'etection d'angle}
Notre d\'etection de l'angle de rotation d'un texte dans une image est
encore assez impr\'ecise ; cela est principalement d\^u \`a l'utilisation
de l'arctangente qui devient tr\`es sensible aux extrema. Nous pensons
donc r\'eutiliser la technique de la multiple rotation, qui semble en
th\'eorie plus pr\'ecise.
\subsubsection{ Optimisation des filtres}
Le gros probl\`eme de la rotation est la perte d'information, en effet
cette transformation a en sortie des nombres \`a virgule flottante,
ce qui ne correspond pas vraiment aux nombres entiers d\'efinissant la
grille d'une image dans le cas de pixels carr\'es. Une multitude de
filtres existent, mais le plus rapide et le plus adapt\'e dans le cas de la
rotation serait un filtre bicubique.
%%vive le copier coller a remanier en trente secondes:D
\Chapter{Utilisation de OCRed dans OCRe}
\section{Pourquoi?}
Notre programme, est cr\'ee dans l'optique d'une utilisation par un
consomateur lambda, dans cette optique, nous avons du cr\'eer diff\'erents
outils, qui communiquant entre eux, forment un tout unique et
merveilleux, OCRe.
OCRed \`a \'et\'e battit dans l'objectif de faciliter de le
pr\'etraitement, tache tr\'es difficile r\'ealis\'e par le programme segmentation.

%% fin du chapitre sur le pretraitement

%% debut du chapitre sur les reseaux de neuronnes
\chapter{ R\'eseau de Neurones Formels?}
%%mettre ca en jolie pour TESTU
fait par guilbep et dimok
%%mettre ca en jolie pour TESTU

\section{ Qu'est-ce qu'un RNF?}
Un RNF est un r\'eseau de neurones form\'els, bon jusque l\'a vous me
suivez, quoique pas sur. On va essayer d'y remedier.
\subsection{Historique}
Le domaine des r\'eseaux de neurones, dont les traditions sont
anciennes, a \'et\'e saisi par une p\'eriode d'effervescence
the\'eorique et interdisciplianire pendant les ann\'ees quatre-vingt,
suivie par une phase d'explorations tous azimuts au cours de la
d\'ecennie suivant. Ca c'est pour l'introduction.
Pendant les ann\'ees 1980, les travaux et recherches sur les neurones
formels rassemblaient une multitude de chercheurs venant d'horizons
tout aussi divers que la physique statistique, la biologie,
la psychologie et l'ing\'enierie, qui esp\'erer profiter de cette
situation.

Collaborations entre biologistes et physiciens se sont prolong\'e
surtout sur des probl\`emes th\'eoriques dans les ann\'ees 90. A cette
m\'eme \'epoque, les ing\'enieurs ont d'ailleurs commenc\'es la
r\'ealisation gr\^ace aux rnfs, de syst\'emes fonctionnels en
reconnaissance de formes et en mod\'elisation non-lin\'eaire.
Ces derni\`eres avanc\'ees sont notamment du aux r\'esultats
math\'ematiques et statistiques importants qui on vu le jour en ce
d\'ebut de d\'ecennie(1990 j'entends). De plus la
recherches dans ce domaine, qui n'a pas cess\'e, a apport\'e de nombreuses solutions
d'optimisation ces derni\'eres ann\'ees, principalement pour les
prob\'emes d'estimations des param\'etres du reseaux, et des
m\'ethodes d'\'evaluation de la qualit\'e d'un classifieur.

Rappelons, qu'au d\'epart l'on a appell\'e cela par analogie avec les
syst\'emes biologiques, car oui nous sommes tous dot\'ees plus ou
moins d'un certain nombres de neurones. M\^eme moi.

Aujourd'hui principalement \'a cause de la nature statistiques des
r\'eseaux de neurones, cette analogie semble devenir d\'esu\`ete.
On pourrait m\^eme dire que les pseudo-justifications biologiques des
architectures et des algorithmes ne sont plus de mise, mais l\`a ce
n'est pas de moi.

Et l\`a normalement vous me dites, et avant les ann\'ees quatre-vingt
y'avait quoi? Bonne question: \dots d'apr\`es mes sources, une certaine
personne du nom de Marvin Minsky, connu pour ses th\'eories sur la
hierarchisation du syst\'eme de pens\'ees humain, mais aussi pour sa
d\'ecouverte de l'inutilit\'e du r\'eseau de neurones formels tels
qu'il \'etait envisag\'e dans les ann\'ees 70. Rummelhart introduit
alors le perceptrons multicouches en 1984, dont la grande nouveaut\'e
est la r\'etropropagation du gradient.

\subsection{Ca sert a quoi?}
Bon c'est bien beau tout \c ca mais a quoi  \c ca sert? On a
dej\'a effleur\'e le sujet dans l'historique, mais on va
approfondir. Les r\'eseaux de neurones formels servent
particuli\'erement \`a la mod\`elisation statique et dynamique, la
commande de processus, et la classification. Vous allez me dire
comment une simple structure de donn\'ees avec deux trois m\'ethodes
peut reconnaitre un objet, mod\`eliser un syst\`eme dynamique? C'est
ce que j'appelle une question.
les rnfs dont il est question ici doivent etre consideres comme des familles de fonctions aprametres
modulaoires et possedant de bonne sproprietes
d'approxiamation. Pourquoi parceque leur application leur demande
d'etre ainsi.
De nombreux problemes industriesl ou de recherche demandent de
representer a laide dun modele mathermatique le comportement de
processus physiques chimisues economoiques etc.. a partir de
connaissance a priori sur ce comprotement et de mesures effecturees
sur le processus un tel modele peut etre constriot pour, :
analyser les phenomenes regissant le comportement du processus;
predire a court ou a long terme les grandeurs d'inteeret du processus
concevoir un sustemen de commande du processus
Ou on a un processus qui est une entite qui fournit un ou plusieurs
grandeurs qui nous interessent. cette grandeur peut etre n'importe
quoi pourvu qu'elle nous interesse, cela peut etre un debit, un
potentiel pour un processus de production une population ou encore
pour un processus biologique ecologique.., par exemple des poissons?
Generalement cette grandeur d'interet et la sortie de notre reseau de
neurones.

Bon en resume, on peut dire qu'un reseau de neurones ca sert
principalement a trois domaines, la classification ou la
reconnaissance de motifs, la modelisation de systeme biologique,
industrielle, mecanique, et la commande de processus ou automate pour
les intimes. Le principale avantage des reseaux de neuronnes par
rapport a des modeles dit de systeme statistiques, ou expert la
rapidite. Cela est principalement du a la faible quantite de calcule
pour l'utilisation  d'un reseau de neurones formels.
\subsection{Diff\'erent Mod\`ele}

Il existe de nombreux mod\'eles de reseaux de neurones formels, mais
bon principalement, comme on l'a expliqu\'e plus haut, c'est un
syt\`eme qui nous donne une sortie qui d\'epend d'entr\'ees externes
ou pas. Le premier mod\`ele qui nous vient \`a l'esprit est le
mod\`ele dit de ``boites noires'' , il y'a ensuite les mod\`eles dit
lin\'eaires et non-lin\'eaires et puis finalement le mod\`eles qui
d\'ependent du temps, de fa\c con discr\`ete ou continue. Sachant
qu'on peut m\'elanger raisonnablement ces diff\`erentes propri\'etees.
Un mod\`ele de type boite noire, peut-etre non-lin\'eaire par rapport
\`a ses param\'etres ou bien le contraire, le mod\`ele de la boite
noire s'utilise aussi bien pour \'etudier le comportement statiques
d'un transistor MOS en saturation, que le mod\'ele d'une r\'eaction
enzymatique par rapport \`a son substrat.

Les rnfs sont des familles de fonctions non limeaire modulaires
capables d'approxumer n'importe quelle fonction bornmee dans un
intervalle derme de ses entrees aussi complexe soit=elel. c'est l'une
des raison pour lesquelles le rnds sont utilises comme modeles
oit-noir non linmeaire statiques(reseau non boucle, donc sans
retroaction)..et modele dit dynamique(reseau boucle, avec
retroaction). La mise au point d'un modele neuronal consiste a
calculer ses parametres de telle sorte que la sortie du modele predise
celle du processus en moenne . en termes statistiques on desire
estimer les parametres de telle facon que la sortie du modele soit
aussii proche que possible de l'espereance mathematique de la sorite
du processsus . Cette espeance mathemqtique auqui est une fonctione
inconnue des entrees est appelle la regression. l'estimation de
sparametres appele apprentissage dans la communautre neuronale est
realise  a l'aide d'un ensemble d'apprentissage constitu\'e de couples
de valeurs d'entres et de sorties appel\'e exemples d'apprentissage.

%% mettre plein d'images kikoo lol
\subsection{Exemple}
Par exemple un classifieur: on veut proceder a la classification de
chiffres decimaux manuscrits: les entrees prennent les valeurs - ou 1
selon celles de pixels de l'images binarise du chiffre presente. Les
classe d'appartencae sont {0 1 2 3 4 5 6 7 8 9}.
Un classifieur est ainsi ocncyu pour attribuer un objet represente ar
un vecteur d'entree a une classe d'appartencance. Par exemple dans le
cas d'un probleme a deux classe la sortie du classifieur est une
variable qui prend la valeur 1 pour la premiere classe et 0 pour la
deuxieme.
En gros, et pour faire simple on a une espece de representation des
entrees/sorties sur un plan en deux dimensions, on trace une
courbe.. et d'un cote on a la valeur de sortie a un, et de l'autre
cote on a la valeur de sortie a 0.

Et maintenant des images parce nous le valons bien:

%% mettre plein d'image kikkoo lol 2
%% tu les mets toutes la dedans et puis je te sors les commentaires
%% pour les images



%%% PARTIE DE DIMMII


\chapter{Notre reseau de neurones} % (fold)
\label{cha:notre_reseau_de_neurones}
Les rnfs sont des familles de fonctions non limeaire modulaires
capables d'approxumer n'importe quelle fonction bornmee dans un
intervalle derme de ses entrees aussi complexe soit=elel. c'est l'une
des raison pour lesquelles le rnds sont utilises comme modeles
oit-noir non linmeaire statiques(reseau non boucle, donc sans
retroaction)..et modele dit dynamique(reseau boucle, avec
retroaction). La mise au point d'un modele neuronal consiste a
calculer ses parametres de telle sorte que la sortie du modele predise
celle du processus en moenne . en termes statistiques on desire
estimer les parametres de telle facon que la sortie du modele soit
aussii proche que possible de l'espereance mathematique de la sorite
du processsus . Cette espeance mathemqtique auqui est une fonctione
inconnue des entrees est appelle la regression. l'estimation de
sparametres appele apprentissage dans la communautre neuronale est
realise  a l'aide d'un ensemble d'apprentissage constitu\'e de couples
de valeurs d'entres et de sorties appel\'e exemples d'apprentissage.

%% mettre plein d'images kikoo lol
\subsection{Exemple}
>>>>>>> .r293
Par exemple un classifieur: on veut proceder a la classification de
chiffres decimaux manuscrits: les entrees prennent les valeurs - ou 1
selon celles de pixels de l'images binarise du chiffre presente. Les
classe d'appartencae sont {0 1 2 3 4 5 6 7 8 9}.
Un classifieur est ainsi ocncyu pour attribuer un objet represente ar
un vecteur d'entree a une classe d'appartencance. Par exemple dans le
cas d'un probleme a deux classe la sortie du classifieur est une
variable qui prend la valeur 1 pour la premiere classe et 0 pour la
deuxieme.
En gros, et pour faire simple on a une espece de representation des
entrees/sorties sur un plan en deux dimensions, on trace une
courbe.. et d'un cote on a la valeur de sortie a un, et de l'autre
cote on a la valeur de sortie a 0.

<<<<<<< .mine
\section{Introduction} % (fold)
\label{subsec:introduction}
A l'issue de la premi\`ere soutenance, nos recherches sur les r\'eseaux
neuronaux nous avaient men\'es vers l'\'elaboration d'un perceptron
multicouches, celui-ci \'etant reconnu comme la star de la
reconnaissance de caract\`eres.
=======
Et maintenant des images parce nous le valons bien:

%% mettre plein d'image kikkoo lol 2
%% tu les mets toutes la dedans et puis je te sors les commentaires
%% pour les images

\section{RNF et OCRe}
\subsection{Quel mod\`ele a-t-on choisi?}
\subsection{Quelle structure pour notre RNF?}
\subsection{Exp\'eriences et rat\'es}
\subsection{Conclusion}
>>>>>>> .r293

Le temps a pass\'e', \'ecrivait G\'erard de Narval, pensant \`a sa jeunesse
et toutes ces belles ann\'ees d\'esormais r\'evolues... En ce qui
concerne le r\'eseau de neurones, le temps a \'egalement pass\'e et
notre perceptron multicouches commence \`a prendre de l'allure. Sa
jeunesse n'\'etant pas encore r\'evolue, grand bien lui fasse, il a
encore beaucoup \`a apprendre... Alors
certes il ne reconna\^it pas encore grand chose, mais une premi\`ere
\'ebauche de sa structure est pr\^ete et les premiers tests ont \'et\'e
effectu\'es sur les donn\'ees d'un XOR et celles d'un afficheur sept
segments. La phase d'apprentissage reste \`a mettre au point car la
version actuelle ne donne pas les r\'esultats attendus. Mais ne parlons
pas de malheur, et rentrons d\`es \`a pr\'esent dans le vif du sujet : what about
multi-layer perceptron ?! 

Nous d\'ecrirons ici le perceptron tel que nous l'avons abord\'e, c'est \`a
dire \`a un stade encore exp\'erimental. Pour motiver sa conception,
nous nous sommes plac\'es dans le cas o\`u notre r\'eseau devra
reconna\^itre les caract\`eres provenant d'un afficheur sept
segments. En effet, les donn\'ees d'un tel alphabet sont assez simples
\`a formater sans pour autant atteindre le niveau de simplicit\'e d'une
fonction logique de base comme le OR ou l\'eg\`erement plus avanc\'ee
comme le XOR

% subsection introduction (end)
\pagebreak
\section{Structure et d\'efinitions} % (fold)
\label{subsec:structure_et_definitions}

Voici ce \`a quoi ressemble la b\^ete :
\begin{center}
	
	\includegraphics[width=120mm]{ra-perceptron.png}\\
	\caption{\emph{Perceptron \`a une couche cach\'ee}}\\
\end{center}

%pour ce paragraphe j'aimerais une liste à puce à la place de mes étoiles
%=)
Un perceptron est un ensemble de neurones reli\'es par des connexions
pond\'er\'ees. Ce n'est rien d'autre qu'un graphe non-orient\'e valu\'e
en somme, du moins en apparence. On y rep\`ere trois ensembles
particuliers de neurones que sont : 
%debut de liste à puce
*la couche d'entr\'ee : elle poss\`ede un certain nombre de neurones qui
correspondent \`aux entr\'ees du r\'eseau. La mod\'elisation et le
formatage des donn\'ees d'entr\'ee sont donc primordiaux si l'on veut
\'eviter d'avoir un trop grand nombre de neurones, ce qui augmenterait
le temps de la reconnaissance par la suite.

*la ou les couches cach\'ee(s) : ce sont ces neurones qui permettront de
reconna\^itre des donn\'ees. Le nombre de couches cach\'ees et de
neurones par couche est \`a adapter selon le probl\`eme et en
particulier selon la taille de l'\'echantillon de donn\'ees que l'on veut
apprendre au r\'eseau.

*la couche de sortie : ce sont ces neurones qui contiendront le
r\'esultat de la reconnaissance. Il y en a, a priori, autant que
d'\'elements \`a reconna\^itre, mais une seule sortie ensuite filtr\'ee
par une table de hachage,par exemple, reste envisageable.
%fin de liste a puce

% Mettre cette photo ici !

\begin{center}
	
	\includegraphics[width=70mm]{sortie008.png}\\
	\caption{\emph{Perceptron \`a une sortie}}\\
\end{center}




% avec la légende suivante : Perceptron \`a une sortie

La valeur d'un neurone est calcul\'ee \`a partir des valeurs de chacun
des neurones de la couche pr\'ec\'edente.

Les neurones artificiels ainsi \'evoqu\'es sont en fait tr\`es proches
des neurones naturels au niveau de leur fonctionnement. C'est entre
autres l'id\'ee d'int\'eractions avec une multitude d'autres neurones
qui permet au r\'eseau de se constituer une ``m\'emoire intelligente'',
apte \`a classifier ou reconna\^itre des donn\'ees qu'il n'a encore
``jamais'' rencontr\'ees auparavant (du moins pas exactement sous la
même forme) !

Avant de pouvoir utiliser un perceptron multicouches, il faut avant tout se mettre d'accord sur le
format de donn\'ees qu'il prendra en entr\'ee, puis effectuer un choix
judicieux de son nombre de couches cach\'ees et de son nombre de neurones
par couche cach\'ee. On doit ensuite ``entra\^iner'' le r\'eseau\ldots

% subsection structure_et_definitions (end)

\section{Formatage des donn\'ees} % (fold)
\label{subsec:formatage_des_donnees}

Pour que le r\'eseau reconnaisse, dans notre cas, si un caract\`ere est
telle ou telle lettre, il faut affecter une valeur pr\'ecise à chacun de
ses neurones d'entr\'e.
Parmi les id\'ees qui nous sont venues, il y a l'extraction de
caract\'eristiques des caract\`eres que l'on a isol\'e \`a partir du document
scann\'e. Ainsi l'on pourrait envisager de vectoriser chaque caract\`ere
afin d'en extraire des segments caract\'eristiques que l'on donnerait en
entr\'ee au r\'eseau. On pourrait aussi imaginer effectuer une premi\`ere
classification par crit\`ere de largeur, puis de hauteur, etc, en utilisant
plusieurs r\'eseaux en s\'erie par exemple, jusqu'\`a d\'etermination totale du
caract\`ere.

La m\'ethode que nous avons retenue \`a ce jour est n\'eanmoins bien
plus simpliste, et pas n\'ecessairement moins efficace : notre
perceptron recevra directement la matrice de pixels associ\'ee au
caract\`ere \`a reconna\^itre, apr\`es calibrage et centrage de chaque
caract\`ere dans une matrice de taille fixe.
Chaque neurone d'entr\'ee du r\'eseau recevra donc l'un des pixels de la
matrice de caract\`ere (d'o\`u la n\'ecessit\'e de r\'eduire au maximum
la taille et l'\'epaisseur de nos caract\`eres, afin de ne pas
d\'epasser la centaine de neurones d'entr\'ee).
Les donn\'ees d'apprentissage seront quant \`a elles pr\'esent\'ees sous
forme de couples de vecteurs d'entr\'ees/sorties au r\'eseau et
stock\'ees dans un fichier.


% subsection formatage_des_donnees (end)

\section{Param\`etres du r\'eseau} % (fold)
\label{subsec:choix_des_parametres_du_reseau}

Une fois les donn\'ees format\'ees et stock\'ees dans un fichier, il
faut choisir un certain nombre d'éléments clés du réseau.

Nous avons donc choisi d'affecter chaque pixel de la matrice du
caract\`ere \`a reconna\^itre \`a un neurone d'entr\'ee.

Dans le mod\`ele retenu actuellement, nous pr\'evoyons aussi d'affecter
un neurone de sortie par caract\`ere \`a reconna\^itre. Le caract\`ere
reconnu sera celui dont la valeur sera \`a un alors que les autres seront
rest\'es \`a z\'ero.

Pour ce qui est des couches cach\'ees, il est recommand\'e dans le cas
de la reconnaissance de caract\`eres d'en prendre entre une et deux, et
de choisir un nombre de neurones par couche du m\^eme ordre de grandeur
que le nombre de neurones de la couche de sortie. Mais nous essayerons
plusieurs configurations jusqu'\`a obtenir des r\'esultats
performants.

Un certain nombres de param\`etres relatifs \`a l'apprentissage des
donn\'ees par le r\'eseau doivent \'egalement \^etre fix\'es. Nous en
ferons une br\`eve description dans la section ``Entra\^inement du r\'eseau.''

% subsection choix_des_parametres_du_reseau (end)

\section{Entra\^inement du r\'eseau} % (fold)
\label{subsec:entrainement_du_reseau}

Cette partie est tr\`es probablement la plus int\'eressante de
l'impl\'ementation du perceptron multicouches. C'est en effet ici que
l'on doit mettre en oeuvre le fonctionnement du r\'eseau \`a proprement
parler. 

Son principe est le suivant :

Dans un premier temps, on affecte des petites valeurs \`a tous les poids
des connexions neuronales (entre 0,5 et -0,5 dans notre cas).

Ensuite, pour un nombre d'it\'erations donn\'e par exemple, ou bien tant
que l'erreur totale du vecteur de sorties est supérieure à un seuil fixé, on effectue
les \'etapes suivantes :

On permute l'ordre des donn\'ees que l'on pr\'esente au r\'eseau, ceci
d'uniformiser l'apprentissage, de sorte \`a ce qu'il n'apprenne pas \`a reconna\^itre toujours la m\^eme
s\'equence de donn\'ees.

On fournit ensuite un couple d'entr\'ees/sorties d\'esir\'ees au
r\'eseau.

Il faut maintenant propager vers l'avant les valeurs des neurones
d'entr\'ee, de sorte \`a obtenir les valeurs de sortie.

Pour cela on utilise une fonction de combinaison, ici une somme
pond\'er\'ee sum, dans notre cas
d\'efinie comme, pour chaque neurone ni, la somme des produits des valeurs
des neurones nj qui pointent sur lui par les poids des connexions pij qui les
lient au neurone courant :

\[sum(ni) = somme\, sur\, j\, (pij(ni,nj)* valeur(nj))
\]% une formule en LaTeX serait plus jolie ici
\\

\begin{center}
	
	\includegraphics[width=70mm]{neuron.jpg}\\
	\caption{\emph{Calcul de la sortie d'un neurone}}\\
\end{center}




Cette valeur est ensuite pass\'ee en param\`etre d'une fonction
d'activation propre au perceptron, ici la fonction sigmo\"ide f avec :  

\[f(sum(ni)) = 1/(1+exp(-sum(ni))) 
\]% une formule en LaTeX serait plus jolie ici

On obtient ainsi une valeur exp\'erimentale pour chaque neurone de
sortie que l'on va pouvoir confronter \`a la valeur th\'eorique fournie
initialement.

On calcule donc l'erreur e observ\'ee pour chaque neurone de sortie ni avec :

\[
	e(ni) = (valeur\, theorique(ni)\, -\, valeur\, observee(ni))*(f'(sum(ni)))
\]

% une formule en LaTeX serait plus jolie ici

On propage ensuite l'erreur vers les couches intérieures 

Puis on modifie les poids de toutes les connexions du réseau.

Et voilà, notre réseau marche !! Du moins pour apprendre le XOR !! Car
nous avons hélas manqué de temps pour conclure ce merveilleux projet et
nous comptons bien sur les vacances d'été pour le recoder intégralement
!



% subsection entrainement_du_reseau (end)

\subsection{Le banc de tests du perceptron} % (fold)
\label{subsec:le_banc_de_tests_du_perceptron}

Un petit shell a \'et\'e impl\'ement\'e afin de tester notre perceptron
au fur et \`a mesure de sa cr\'eation. Il est lanc\'e par d\'efaut lors
de l'ex\'ecution du programme ``network'' et propose diverses
options. 
%une grosse liste à puce please !
\begin{itemize}
	\item Trois fonctions d'affichage sont disponibles : 
\begin{description}
	\item[\verb!dispc! :] affiche l'\'etat des connexions neuronales et leur nombre
	\item[\verb!dispn! :] affiche l'\'etat des neurones et leur nombre
	\item[\verb!dispo! :] affiche les valeurs du vecteur de sorties (outputs)
\end{description}
%fin de liste, merci !

\item On peut initialiser le r\'eseau avec la fonction init, qui demandera
successivement de renseigner le nombre de couches cach\'ees d\'esir\'ees
ainsi que le nombre de neurones par couche cach\'ee.

\item La fonction train entra\^ine le r\'eseau (pour l'instant assez mal, il
faut l'admettre) 

\item La fonction active effectue une simple propagation des valeurs
d'entr\'ee vers celles de sortie

\item La fonction run permet (Bertrand) quant \`a elle, de pr\'eciser l'indice de la donn\'ee
que l'on souhaite tester (donn\'ee pr\'esente dans data.ml ; la donn\'ee
par d\'efaut est celle correspondant au XOR, il suffit de swaper les
noms de datatab et datatab2 dans data.ml pour acc\'eder au vecteur de
donn\'ees de l'afficheur sept segments !)

\item Enfin une fonction load et une fonction save sont pr\'esentes pour une
impl\'ementation future proche !? Prévu pour le mois d'août donc !

\end{itemize}

%fin de grosse liste à puce danke schön !

Un jour, ce shell de test sera am\'elior\'e et compl\'et\'e afin de rendre les
tests de notre r\'eseau rapides et efficaces. Il n'est pas destin\'e \`a
l'utilisateur final et c'est pourquoi nous avons pris quelques
libert\'es quant \`a son nombre de ligne de code.
On pourra bient\^ot pr\'eciser l'ensemble des param\`etres et
coefficients du r\'eseau via le shell, ce qui nous permettra
d'identifier clairement les options que nous t\^acherons,
,\'eventuellement dans une autre vie, de linker \`a une interface graphique
sp\'ecifique au r\'eseau qui sera enti\`erement param\'etrable et donc
r\'eutilisable \`a part enti`ere pour d'autres projets.

La HUGE team, c'est avant tout une team. Ce n'est que dans un second
temps que l'on se rend compte \`a quelle point, en plus d'\^etre une
team, c'est une team HUGE !!!  
%subsection le_banc_de_tests_du_perceptron (end)

% section notre_reseau_de_neurones (end)


%% fin du chapitre sur les reseaux de neuronnes
%%
%% + Reprise du cahier des charges,
%% + Plusieurs presentations possibles :
%%      - Chronologique (groupe),
%%      - Chronologique (individuelle),
%%      - Individuelles (repartition des taches),
%%      - Autres.
%% + Recit de la realisation :
%%      - Ses joies,
%%      - Ses peines,
%%      - Etc.
%% + Les annexes comprennent :
%%      - Les exemples d'impression,
%%      - les exemples d'       cran,
%%      - les jeux d'essai,
%%      - les dessins d'origine,
%%      - Etc.t
